﻿//using System;
//using System.Net;
//using System.Net.Sockets;
//using System.Threading;
//using System.Text;

//namespace dataSendModel.Util
//{
//    /// <summary>
//    /// 异步socket客户端类
//    /// </summary>
//    public class AsynchronousClient
//    {
//        private string ip;  // Socket IP Address
//        private string port;// Socket Port
//        private string response = String.Empty;   // The response from the remote device
//        private byte[] responseByte = null;

//        public string Response
//        {
//            get { return response; }
//        }

//        public byte[] ResponseByte
//        {
//            get { return responseByte; }
//        }

//        // ManualResetEvent instances signal completion.
//        // 一个或多个正在等待的线程已发生事件
//        private static ManualResetEvent connectDone =
//            new ManualResetEvent(false);
//        private static ManualResetEvent sendDone =
//            new ManualResetEvent(false);
//        public static ManualResetEvent receiveDone =
//            new ManualResetEvent(false);

//        /// <summary>
//        /// Socket服务器端口
//        /// </summary>
//        public string Port
//        {
//            get { return port; }
//            set { port = value; }
//        }

//        /// <summary>
//        /// Socket服务器IP地址
//        /// </summary>
//        public string Ip
//        {
//            get { return ip; }
//            set { ip = value; }
//        }

//        /// <summary>
//        /// 异步socket客户端构造函数
//        /// </summary>
//        /// <param name="ip">Socket服务器IP地址</param>
//        /// <param name="port">Socket服务器端口</param>
//        public AsynchronousClient(string ip, string port)
//        {
//            this.ip = ip;
//            this.port = port;
//        }

//        public Socket Start()
//        {
//            Socket client = null;

//            try
//            {
//                // Connect to a remote device.

//                IPAddress ipAddress = IPAddress.Parse(ip);
//                IPEndPoint ipe = new IPEndPoint(ipAddress, Int32.Parse(port));

//                // Create a TCP/IP socket.
//                client = new Socket(AddressFamily.InterNetwork,
//                    SocketType.Stream, ProtocolType.Tcp);

//                // Connect to the remote endpoint.

//                client.BeginConnect(ipe,
//    new AsyncCallback(ConnectCallback), client);
//                //connectDone.WaitOne();

//            }
//            catch (Exception ex)
//            {

//                throw ex;
//            }

//            return client;

//        }

//        public void ConnectCallback(IAsyncResult ar)
//        {
//            try
//            {
//                // Retrieve the socket from the state object.
//                Socket client = (Socket)ar.AsyncState;

//                // Complete the connection.
//                client.EndConnect(ar);

//                Console.WriteLine("Socket connected to {0}",
//                    client.RemoteEndPoint.ToString());

//                // Signal that the connection has been made.
//                connectDone.Set();
//            }
//            catch (Exception)
//            {
//                //Console.WriteLine(e.ToString());
//            }
//        }

//        public void Receive(Socket client)
//        {
//            try
//            {
//                // Create the state object.
//                StateObject state = new StateObject();
//                state.workSocket = client;

//                // Begin receiving the data from the remote device.
//                client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
//                    new AsyncCallback(ReceiveCallback), state);
//            }
//            catch (Exception)
//            {
//                //Console.WriteLine(e.ToString());
//            }
//        }

//        public void ReceiveCallback(IAsyncResult ar)
//        {
//            try
//            {
//                // Retrieve the state object and the client socket 
//                // from the asynchronous state object.
//                StateObject state = (StateObject)ar.AsyncState;
//                Socket client = state.workSocket;

//                // Read data from the remote device.
//                int bytesRead = client.EndReceive(ar);

//                if (bytesRead > 0)
//                {
//                    // There might be more data, so store the data received so far.
//                    state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));

//                    response += state.sb.ToString();
//                    responseByte = state.buffer;
//                    //Console.WriteLine("Response received : {0}", response);

//                    // Get the rest of the data.
//                    client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
//                        new AsyncCallback(ReceiveCallback), state);
//                }
//                else
//                {
//                    // All the data has arrived; put it in response.
//                    if (state.sb.Length > 1)
//                    {
//                        response = state.sb.ToString();
//                    }
//                    // Signal that all bytes have been received.
//                    receiveDone.Set();
//                }
//            }
//            catch (Exception)
//            {
//                //Console.WriteLine(e.ToString());
//            }
//        }

//        public void Send(Socket client, Byte[] byteData)
//        {
//            // Convert the string data to byte data using ASCII encoding.
//            //byte[] byteData = Encoding.ASCII.GetBytes(data);

//            // Begin sending the data to the remote device.
//            if (client != null)
//            {
//                if (client.Connected)
//                {
//                    client.BeginSend(byteData, 0, byteData.Length, 0,
//                        new AsyncCallback(SendCallback), client);
//                }
//            }
//        }

//        public void SendCallback(IAsyncResult ar)
//        {
//            try
//            {
//                // Retrieve the socket from the state object.
//                Socket client = (Socket)ar.AsyncState;

//                // Complete sending the data to the remote device.
//                //int bytesSent = client.EndSend(ar);
//                //Console.WriteLine("Sent {0} bytes to server.", bytesSent);

//                // Signal that all bytes have been sent.
//                sendDone.Set();
//            }
//            catch (Exception)
//            {
//                //Console.WriteLine(e.ToString());
//            }
//        }

//        public void Close(Socket client)
//        {
//            // Release the socket.
//            if (client != null)
//            {
//                if (client.Connected)
//                {
//                    client.Shutdown(SocketShutdown.Both);
//                    client.Close();
//                }

//            }
//        }

//    }

//    /// <summary>
//    /// 从远程终端接收数据状态对象类
//    /// </summary>
//    public class StateObject
//    {
//        // Client socket.
//        public Socket workSocket = null;
//        // Size of receive buffer.
//        public const int BufferSize = 256;
//        // Receive buffer.
//        public byte[] buffer = new byte[BufferSize];
//        // Received data string.
//        public StringBuilder sb = new StringBuilder();
//    }
//}
